package com.epfresh.global;


import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.os.Build;
import android.support.v4.app.NotificationCompat;


import com.epfresh.BuildConfig;
import com.epfresh.R;
import com.epfresh.api.constant.Constant;
import com.epfresh.api.entity.DocFile;
import com.epfresh.api.entity.*;
import com.epfresh.api.entity.RequestTag;
import com.epfresh.api.entity.ResponseEntity;
import com.epfresh.api.entity.User;
import com.epfresh.api.entity.Version;
import com.epfresh.api.global.AppApplication;
import com.epfresh.api.helper.ApplicationHelper;

import com.epfresh.api.http.DownloadFile;
import com.epfresh.api.http.HttpRequest;
import com.epfresh.api.http.OnRequestListener;
import com.epfresh.api.http.RequestManager;
import com.epfresh.api.http.volley.DefaultRetryPolicy;
import com.epfresh.api.http.volley.RetryPolicy;
import com.epfresh.api.universalimageloader.cache.disc.impl.UnlimitedDiskCache;
import com.epfresh.api.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.epfresh.api.universalimageloader.cache.memory.impl.UsingFreqLimitedMemoryCache;
import com.epfresh.api.universalimageloader.core.DisplayImageOptions;
import com.epfresh.api.universalimageloader.core.ImageLoader;
import com.epfresh.api.universalimageloader.core.ImageLoaderConfiguration;
import com.epfresh.api.universalimageloader.core.assist.ImageScaleType;
import com.epfresh.api.universalimageloader.core.assist.QueueProcessingType;
import com.epfresh.api.universalimageloader.core.display.FadeInBitmapDisplayer;
import com.epfresh.api.universalimageloader.core.download.BaseImageDownloader;

import com.epfresh.api.update.Constants;
import com.epfresh.api.update.DownloadService;
import com.epfresh.api.update.UpdateApkDialogActivity;
import com.epfresh.api.utils.AppUtils;
import com.epfresh.api.utils.FileUtil;
import com.epfresh.api.utils.L;
import com.epfresh.api.utils.LocalDisplay;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.umeng.commonsdk.UMConfigure;
import com.umeng.socialize.PlatformConfig;


import java.io.File;
import java.util.HashMap;
import java.util.Map;

import cn.jpush.android.api.JPushInterface;


/**
 * Created by wzh on 2016/3/16.
 */
public class BaseApplication extends AppApplication {
    public static BaseApplication instance;
    private String clientIdentifierCode;

    //   private StoreInfo storeInfo;

    public static boolean isHomeActivityAlive;
    public static int loginActivityCount = 0;

    public static DocFile docFile;

    public String docFileName = "doc.json";

//    public String appUrl = "";

    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
        int env = BuildConfig.ENV;

        if (env == 0){//正式版本
            com.epfresh.api.constant.Constant.isDEV = false;
        }else if (env == 1){//rc
            com.epfresh.api.constant.Constant.isDEV = true;
        }else if (env == 2){//beta
            com.epfresh.api.constant.Constant.isDEV = true;
        }else if (env == 3){//dev
            com.epfresh.api.constant.Constant.isDEV = true;
        }

        ApplicationHelper.init(this);
        com.epfresh.api.constant.Constant.ENV = env;
        if (env == 0){//正式版本
            com.epfresh.api.constant.Constant.init(false, getAppDomain());
        }else {//测试版本
            com.epfresh.api.constant.Constant.ENV_CUR = ApplicationHelper.getInstance().getEnv();
            com.epfresh.api.constant.Constant.init(true, getAppDomain());
        }
        //初始化ImageLoader
        initImageLoader();

        //获取设备的唯一ID
        clientIdentifierCode = AppUtils.getUniquePsuedoID();
        L.timeMills();

//        Constant.URL_BASE_TEST="http://10.10.47.1/cgi";
//        Constant.URL_BASE="http://10.10.47.1/cgi";
        JPushInterface.setDebugMode(true);    // 设置开启日志,发布时请关闭日志
        MessageCentre.init(this);
        JPushInterface.init(this);
        getDoc();
        copyDocToInteral();
        //友盟初始化
        UMConfigure.init(this, "57183d7667e58eb318002fd7", "umeng", UMConfigure.DEVICE_TYPE_PHONE, "");
        PlatformConfig.setWeixin("wx724dc919a827351d", "a8537f85a987b52a30f2cd6a61a78bcf");
        PlatformConfig.setQQZone("1105275347", "OYmMN3tZpIF76HN");
//        updateVersion();


    }

    @Override
    public String getAppDomain() {
        return Constant.APP_DOMAIN_PURCHASER;
    }

    @Override
    public String getAppFileProvider() {
        return BaseApplication.getInstance().getPackageName() + ".fileProvider";
    }

    public static BaseApplication getInstance() {
        return instance;
    }

    private void initImageLoader() {
        com.epfresh.api.universalimageloader.utils.Log.writeLogs(false);
        com.epfresh.api.universalimageloader.utils.Log.writeDebugLogs(false);
        DisplayImageOptions options = new DisplayImageOptions.Builder()
                .showImageOnLoading(R.drawable.def_img) // 设置图片在下载期间显示的图片
                .showImageForEmptyUri(R.drawable.def_img)// 设置图片Uri为空或是错误的时候显示的图片
                .showImageOnFail(R.drawable.def_img) // 设置图片加载/解码过程中错误时候显示的图片
                .cacheInMemory(true)// 设置下载的图片是否缓存在内存中
                .cacheOnDisk(true)// 设置下载的图片是否缓存在SD卡中
                .considerExifParams(true) // 是否考虑JPEG图像EXIF参数（旋转，翻转）
                .imageScaleType(ImageScaleType.EXACTLY_STRETCHED)// 设置图片以如何的编码方式显示
                .bitmapConfig(Bitmap.Config.RGB_565)// 设置图片的解码类型//
                // .decodingOptions(new Options())//设置图片的解码配置
                // .delayBeforeLoading(int delayInMillis)//int
                // delayInMillis为你设置的下载前的延迟时间
                // 设置图片加入缓存前，对bitmap进行设置
                // .preProcessor(BitmapProcessor preProcessor)
                .resetViewBeforeLoading(true)// 设置图片在下载前是否重置，复位
//                .displayer(new RoundedBitmapDisplayer(20))// 是否设置为圆角，弧度为多少
                .displayer(new FadeInBitmapDisplayer(300, true, false, false))// 是否图片加载好后渐入的动画时间
                .build();// 构建完成
        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(this).memoryCacheExtraOptions(LocalDisplay.SCREEN_WIDTH_PIXELS, LocalDisplay.SCREEN_HEIGHT_PIXELS)
                // max width, max height，即保存的每个缓存文件的最大长宽
//                .diskCacheExtraOptions(480, 800, null)
                // Can slow ImageLoader, use it carefully (Better don't use
                // it)/设置缓存的详细信息，最好不要设置这个
                .threadPoolSize(2)
                // 线程池内加载的数量
                .threadPriority(Thread.NORM_PRIORITY - 2).denyCacheImageMultipleSizesInMemory()
                .memoryCache(new UsingFreqLimitedMemoryCache(2 * 1024 * 1024))
                // You can pass your own memory cache
                // implementation/你可以通过自己的内存缓存实现
                .memoryCacheSize(2 * 1024 * 1024).diskCacheSize(50 * 1024 * 1024)
                .diskCacheFileNameGenerator(new Md5FileNameGenerator())
                // 将保存的时候的URI名称用MD5 加密
                .tasksProcessingOrder(QueueProcessingType.LIFO).diskCacheFileCount(100)
                // 缓存的文件数量
                .diskCache(new UnlimitedDiskCache(new File(FileUtil.getImgCacheDir())))
                // 自定义缓存路径
                .defaultDisplayImageOptions(
                        options/*
                                 * DisplayImageOptions. createSimple()
								 */)
                .imageDownloader(new BaseImageDownloader(this, 5 * 1000, 30 * 1000)) // connectTimeout
                // (5
                // s),
                // readTimeout
                // (30
                // s)超时时间
                // .writeDebugLogs()
                // //
                // Remove
                // for
                // release
                // app
                .build();// 开始构建
        // Initialize ImageLoader with configuration.
        ImageLoader.getInstance().init(config);// 全局初始化此配置
    }

    public static DisplayImageOptions getAvatarOptions(String expectTag) {
        return new DisplayImageOptions.Builder()
                .showImageOnLoading(R.mipmap.my_head) // 设置图片在下载期间显示的图片
                .showImageForEmptyUri(R.mipmap.my_head)// 设置图片Uri为空或是错误的时候显示的图片
                .showImageOnFail(R.mipmap.my_head) // 设置图片加载/解码过程中错误时候显示的图片
                .cacheInMemory(true)// 设置下载的图片是否缓存在内存中
                .cacheOnDisk(true)// 设置下载的图片是否缓存在SD卡中
                .considerExifParams(true) // 是否考虑JPEG图像EXIF参数（旋转，翻转）
                .imageScaleType(ImageScaleType.EXACTLY_STRETCHED)// 设置图片以如何的编码方式显示
                .bitmapConfig(Bitmap.Config.RGB_565)// 设置图片的解码类型//
                .resetViewBeforeLoading(true)// 设置图片在下载前是否重置，复位
                .displayer(new FadeInBitmapDisplayer(300, true, false, false))// 是否图片加载好后渐入的动画时间
                .setExceptTag(expectTag)
                .build();// 构建完成
    }

    public static DisplayImageOptions getCenterOptions(String expectTag) {
        return new DisplayImageOptions.Builder()
                .showImageOnLoading(R.mipmap.store_logo) // 设置图片在下载期间显示的图片
                .showImageForEmptyUri(R.mipmap.store_logo)// 设置图片Uri为空或是错误的时候显示的图片
                .showImageOnFail(R.mipmap.store_logo) // 设置图片加载/解码过程中错误时候显示的图片
                .cacheInMemory(true)// 设置下载的图片是否缓存在内存中
                .cacheOnDisk(true)// 设置下载的图片是否缓存在SD卡中
                .considerExifParams(true) // 是否考虑JPEG图像EXIF参数（旋转，翻转）
                .imageScaleType(ImageScaleType.EXACTLY_STRETCHED)// 设置图片以如何的编码方式显示
                .bitmapConfig(Bitmap.Config.RGB_565)// 设置图片的解码类型//
                .resetViewBeforeLoading(true)// 设置图片在下载前是否重置，复位
                .displayer(new FadeInBitmapDisplayer(300, true, false, false))// 是否图片加载好后渐入的动画时间
                .setExceptTag(expectTag)
                .build();// 构建完成
    }

    public static DisplayImageOptions getTagOptions(String expectTag) {
        return new DisplayImageOptions.Builder()
//                .showImageOnLoading(R.mipmap.my_head) // 设置图片在下载期间显示的图片
//                .showImageForEmptyUri(R.mipmap.my_head)// 设置图片Uri为空或是错误的时候显示的图片
                .showImageOnFail(R.mipmap.my_head) // 设置图片加载/解码过程中错误时候显示的图片
                .cacheInMemory(true)// 设置下载的图片是否缓存在内存中
                .cacheOnDisk(true)// 设置下载的图片是否缓存在SD卡中
                .considerExifParams(true) // 是否考虑JPEG图像EXIF参数（旋转，翻转）
                .imageScaleType(ImageScaleType.EXACTLY_STRETCHED)// 设置图片以如何的编码方式显示
                .bitmapConfig(Bitmap.Config.RGB_565)// 设置图片的解码类型//
                .resetViewBeforeLoading(true)// 设置图片在下载前是否重置，复位
                .displayer(new FadeInBitmapDisplayer(300, true, false, false))// 是否图片加载好后渐入的动画时间
                .setExceptTag(expectTag)
                .build();// 构建完成
    }


    public User getUser() {

        return ApplicationHelper.getInstance().getUser();
    }

    //user不为null
    public void updateUser(User user) {
        ApplicationHelper.getInstance().updateUser(user);
    }

    public void clearUser() {
        ApplicationHelper.getInstance().clearUser();
    }
    public String getClientIdentifierCode() {
        return clientIdentifierCode;
    }

    private boolean isReloginBack;

    public boolean isReloginBack() {
        return isReloginBack;
    }

    public void setReloginBack(boolean reloginBack) {
        isReloginBack = reloginBack;
    }


    public void updateDocFile() {
        String s = FileUtil.readInternal(docFileName);
        if (s != null && !"".equals(s)) {
            DocFile docFile = DocFile.decrypt(s);
            if (docFile != null) {
                BaseApplication.docFile = docFile;
            }
        }
    }

    public void copyDocToInteral() {
        File f = getDocFile();
        if (!f.exists()) {
//            try {
//                File doc = FileUtil.fileFromAsset(getApplicationContext(), docFileName);
//
//                if (doc != null) {
//                    updateDocFile();
//                }
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
        } else {
            updateDocFile();
        }
    }


    private File getDocFile() {
        return new File(FileUtil.getmDataCacheRootPath() + "/" + docFileName);
    }

    public static DocFile getDoc() {
        if (docFile == null) {
            docFile = new DocFile();
            docFile.init();
        }

        return docFile;
    }

    public <T> void request(Object data, Object tag, final OnRequestListener<T> onRequestListener) {
        L.i("requestJson", data.toString());
        if (getUser() != null && getUser().getPhone() != null) {
            MessageCentre.getInstance().sendAlias("getUser().getPhone()");
        }
        if (data instanceof RequestEntity) {
            ((RequestEntity) data).setClientIdentifierCode(getClientIdentifierCode());
            //((RequestEntity) data).setToken(getUser().getToken());
            ((RequestEntity) data).setAppDomain("supplier");
            PackageManager pm = getPackageManager();
            PackageInfo pi = null;
            String appVersion = "";
            try {
                pi = pm.getPackageInfo(getPackageName(), PackageManager.GET_ACTIVITIES);
                appVersion = pi.versionName;
            } catch (PackageManager.NameNotFoundException e) {
                e.printStackTrace();
            }
            HashMap<String, Object> map = new HashMap<>();
            map.put("os", "android");
            map.put("osVersion", Build.VERSION.RELEASE);
            map.put("model", Build.MODEL);
            map.put("registrationID", JPushInterface.getRegistrationID(this));
            ((RequestEntity) data).setDeviceInfo(map);
            ((RequestEntity) data).setAppVersion(appVersion);
        }
        HttpRequest request = new HttpRequest(data, new OnRequestListener() {
            @Override
            public Object jsonToObj(String responseStr) {

                if (onRequestListener != null) {
                    return onRequestListener.jsonToObj(responseStr);
                }
                return null;
            }

            @Override
            public void onFail(int failCode, Object arg, Object tag) {

            }

            @Override
            public void onResponseError(int failCode, Object arg, Object tag) {

            }

            @Override
            public void onStart(Object tag) {
                if (onRequestListener != null) {
                    onRequestListener.onStart(tag);
                }
            }

            @Override
            public void onResponse(ResponseEntity response, Object tag) {
                if (onRequestListener != null) {
                    onRequestListener.onResponse(response, tag);
                }
            }
        });
        request.onStart(tag);
//        if (NetworkUtils.isNetworkAvailable(this)) {
        RetryPolicy retryPolicy = new DefaultRetryPolicy(RequestManager.TIMEOUT_COUNT, RequestManager.RETRY_TIMES, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);
        request.setRetryPolicy(retryPolicy);
        request.setTag(tag);
        RequestManager.getInstance().request(request);
//        } else {
//            requestSilent.onFail(HttpRequest.FAIL_NO_NET, null, tag);
//        }
    }


}
